In practical application of RFID, in many cases, there is one reader corresponding to multiple electronic tags in a radio frequency field. When the reader inventories multiple electronic tags simultaneously, channel contention will appear and collision will occur, so electronic tags are incapable of sending information to the reader correctly. Therefore, some mechanism needs to be adopted to avoid the collision or reduce the possibility of collision.
In the current RFID international standard ISO18000-6, the A-type and C-type adopt the Slotted ALOHA algorithm, and the B-type adopts the Binary Tree algorithm, to solve the collision problem. Both the Slotted ALOHA and Binary Tree algorithms are based on time division multiple access.
The Slotted ALOHA algorithm divides time into several discrete timeslots, requires the tag to select one of the timeslots randomly, and to send data on the boundary of the timeslot. In ISO18000-6 A-type and C-type protocols, the process to achieve collision prevention by using Slotted ALOHA algorithm is: at the beginning of each inventory process, the reader notifies all the tags of a selectable timeslot range, the tag selects one of the timeslots randomly to reply, the tag either sends data successfully or collides completely, and if the collision occurs, the tag reselects a timeslot and sends the data till all the tags send data successfully.
The basic conception of the Binary Tree method is similar to the Depth First Traversal of a Binary Tree; the method splits the tags in collision into two subsets 0 and 1, queries subset 0 first, identifies the tags correctly if there is no conflict, or further splits subset 0 into two subsets 00 and 01 if there is a conflict, and so on, till all the tags in subset 0 are identified, and then queries subset 1 according to these steps. The Binary Tree algorithm is shown in FIG. 1. In ISO18000-6 B-type protocol, the process to achieve collision prevention by using the Binary Tree algorithm is: the reader sends a start inventory instruction to make all the tags begin to reply, and after the tags receive the instruction, a randomizer generates 0 or 1, such that the tags are split into two subsets with the random numbers of 0 and 1, the two subsets are called a left branch (branch 0) and a right branch (branch 1) respectively, corresponding to a Binary Tree herein; the tags with the random number 0, i.e. the tags in the left branch, reply at once and have an innate advantage of prior replying, while the tags with the random number 1, i.e. the tags in the right branch, have to wait till the left branch completes replying before performing splitting and replying; and if there is no collision and the replying is successful, then the reader sends an acknowledgement instruction and makes the counter values of the tags decrease by 1; if the tags collide, the reader sends an instruction to make the tags whose counter values are 0, i.e. the tags in the left branch split again, and for the tags whose counter values are non-zero, i.e. the tags in the right branch, the counter values increase by 1; such process is repeated till all the tags reply successfully.
FIG. 4 illustrates the inventory process of 8 tags, which is the inventory process in ISO18000-6, and the numbers on the right represent the numbers of current timeslots in the inventory process.
Brief description of the inventory process in ISO18000-6 is as follows:                1. timeslot, initializing, counter values of the tags being all 0;        2. timeslot, colliding, splitting into 00001111, the tags whose counter values are 0 replying;        3. timeslot, colliding, and splitting again into 00112222, the tags whose counter values are 0 replying;        4. timeslot, colliding, and splitting again into 01223333, the tag whose counter value is 0 replying successfully;        5. timeslot, the counter values decreasing by 1, being 0112222, the tag whose counter value is 0 replying successfully;        6. timeslot, the counter values decreasing by 1, being 001111, the tags whose counter values are 0 replying;        7. timeslot, colliding, and splitting again into 012222, the tag whose counter is 0 replying successfully; (possibly splitting into 112222 herein, to facilitate the description, setting aside consideration of this situation);        8. timeslot, the counter values decreasing by 1, being 01111, the tag whose counter value is 0 replying successfully;        9. timeslot, the counter values decreasing by 1, being 0000, the tags whose counter values are 0 replying;        10. timeslot, colliding, splitting into 0011, the tags whose counter values are 0 replying;        11. timeslot, colliding, splitting again into 0122, the tag whose counter value is 0 replying successfully (possibly splitting into 1122 herein, to facilitate the description, setting aside consideration of this situation);        12. timeslot, the counter values decreasing by 1, being 011, the tag whose counter value is 0 replying successfully;        13. timeslot, the counter values decreasing by 1, being 00, the tags whose counter values are 0 replying;        14. timeslot, colliding, splitting into 01, the tag whose counter value is 0 replying successfully;        15. timeslot, the counter value decreasing by 1, being 0, the tag whose counter value is 0 replying successfully;        
It takes 15 timeslots to inventory the 8 tags.
From the description of the collision prevention process in ISO18000-6 B-type protocol and the example described above, it can be seen that the process always endeavors to solve the collision of branch 0 first, the branch 0 is made split till it has only one tag left, i.e. a leaf node of the Binary Tree, and after inventory of it, processing of the tags of branch 1 begins, and after processing of the branch 1 is completed, branches 2, 3, . . . , n are processed in sequence, i.e., splitting and inventory are always performed from left to right. During splitting of branch 0, the multiple tags of non-zero branches don't split, and wait for the completion of the inventory of the tags in branch 0. In this way, after the inventory of the branch 0 is completed, subsequent branches will consume a lot of time to execute the splitting process similar to that of branch 0.